package com.zhuzhu.service.impl;

import com.alibaba.fastjson.JSON;

import com.zhuzhu.mapper.ITwoIndex;
import com.zhuzhu.mapper.TwoIndexMapper;
import com.zhuzhu.pojo.TwoIndex;
import com.zhuzhu.pojo.User;
import com.zhuzhu.service.TwoIndexService;
import com.zhuzhu.until.Result;
import com.zhuzhu.until.Useres;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;

import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;

import java.util.concurrent.TimeUnit;

@Service
public class TwoIndexServeImpl implements TwoIndexService {
    @Autowired
    private ITwoIndex iTwoIndex;
    // 声明一个 RedisTemplate 用于与 Redis 进行交互
    @Autowired
    private RedisTemplate redisTemplate;
    @Autowired
    private TwoIndexMapper twoIndexMapper;
    @Autowired
    Useres  useres;

    //    查所有业务
    @Override
    public Result selectAll(TwoIndex twoIndex) {
//        从安全上下文中获取单位
        String principal = (String) SecurityContextHolder.getContext().getAuthentication().getPrincipal();
        User userss = useres.userss(principal);
        twoIndex.setUnit(userss.getUnit());
        if (twoIndex.getYear() == 0 && twoIndex.getUnit() == null) {
            return Result.error("请输入年份和单位");
        }
        if (twoIndex.getWorklog() == null) {
            String redisKey = "部门台账" + twoIndex.getYear() +
                    twoIndex.getUnit() + twoIndex.getProgressstatus() + twoIndex.getAppealstatus();

            // 尝试从Redis中获取缓存的数据
            Object cachedData = redisTemplate.opsForValue().get(redisKey);
            if (cachedData != null) {
                // 如果存在缓存数据，则直接返回
                return Result.ok(cachedData);
            }

            // 如果缓存中没有数据，则从数据库查询
            List<TwoIndex> dbData = twoIndexMapper.selectAll(twoIndex);
            if (dbData != null) {
                if (dbData.isEmpty()) {
                    // 数据库查询结果为空，将一个空列表存入Redis作为缓存
                    redisTemplate.opsForValue().set(redisKey, new ArrayList<TwoIndex>());
                } else {
                    // 将查询结果存入Redis作为缓存
                    redisTemplate.opsForValue().set(redisKey, dbData);
                }
                return Result.ok(dbData);
            }
        }

        // 如果工作台账不为空，或者数据库查询出错，返回错误信息
        return Result.error(555, "未找到数据");
    }


    //   删除业务
    @Override
    public Result batchUpdateById(Integer id) {
//        删除redis中的key为部门台账的表
        redisTemplate.delete("部门台账");
//       更新数据 根据前端传过来的id值，修改工作台账、落实情况、分值、自评分为空
        TwoIndex twoIndex = new TwoIndex();
        twoIndex.setId(id);
        twoIndex.setWorklog("");
        twoIndex.setImplestatus("");
        twoIndex.setScore(0.0);
        twoIndex.setSelfscore(0.0);
        int i = iTwoIndex.updateById(twoIndex);// 假设获取方法为 getById
        if (i > 0) {

            // 更新成功，返回删除成功
            try {
                Thread.sleep(750);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            redisTemplate.delete("部门台账");
            return Result.ok("删除成功");
        } else {
            // 更新失败，返回删除失败
            return Result.error("删除失败");
        }
    }

    //查找
    @Override
    public Result selectById(Integer id) {
//        查询redis缓存，如果工作台账、落实情况、分值、自评分内有内容，则返回内容，如果没有不返回
        String redisKey = "部门台账";
        String redisValue = (String) redisTemplate.opsForValue().get(redisKey);
        if (redisValue != null) {
            return Result.ok(redisValue);
        }
//        如果redis中没有内容，则查询数据库，如果查询出错，返回错误信息
        TwoIndex twoIndex = iTwoIndex.selectById(id);
        if (twoIndex == null) {
            return Result.error("查询错误");
        }
//        如果查询成功，则将查询结果存入redis中，并返回
        redisTemplate.opsForValue().set(redisKey, JSON.toJSONString(twoIndex));
        return Result.ok(twoIndex);
    }


    //根据id 新增/修改 工作台账、落实情况、分值、自评分 业务zhuzh

    @Override
    public Result updateById (TwoIndex twoIndex){

//        当前端发送id执行新增或编辑的时候，需要先判断工作台账、落实情况、分值、自评分的内容是否是为空的，如果
//          不为空则进行先查在修改的操作

        // 删除缓存
        redisTemplate.delete("twoIndexList");
        // 更新数据
        int i = iTwoIndex.updateById(twoIndex);
        // 睡眠
        try {
            TimeUnit.MILLISECONDS.sleep(750); // 延迟0.75秒，以毫秒为单位
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 再次删除缓存
        if (i > 0) {
            // 成功更新数据后，删除对应的缓存
            redisTemplate.delete("twoIndexList");

            return Result.ok("更新成功");
        }

        return Result.error("失败");
    }

//    提交
    @Override
    public Result submit(int id) {

        TwoIndex twoIndex = iTwoIndex.selectById(id);
        if (twoIndex == null) {
            // 根据ID未找到记录，提交失败
            return Result.error("提交失败");
        }
        String currentStatus = twoIndex.getProgressstatus();
        String newStatus = currentStatus.equals("已保存") ? "待审核" : currentStatus;

        // 如果新状态为待审核，执行更新
        if ("待审核".equals(newStatus)) {
            int rowsUpdated = iTwoIndex.updateStatusById(id, newStatus);
            if (rowsUpdated>0){
                return Result.ok("提交成功");
            }
        }
            // 非待审核状态不允许提交
            return Result.error("提交失败");

    }



}




